home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / The World of Computer Software.iso / xgrasp.zip / FADES.C < prev    next >
C/C++ Source or Header  |  1991-07-24  |  12KB  |  425 lines
  1. #ident "@(#)fades.c    1.5 91/04/03 XGRASP"
  2. /*-
  3.  * fades.c - grasp image fader.
  4.  *
  5.  * Copyright (c) 1991 by Patrick J. Naughton
  6.  *
  7.  * Permission to use, copy, modify, and distribute this software and its
  8.  * documentation for any purpose and without fee is hereby granted,
  9.  * provided that the above copyright notice appear in all copies and that
  10.  * both that copyright notice and this permission notice appear in
  11.  * supporting documentation.
  12.  *
  13.  * This file is provided AS IS with no warranties of any kind.  The author
  14.  * shall have no liability with respect to the infringement of copyrights,
  15.  * trade secrets or any patents by this file or any part thereof.  In no
  16.  * event will the author be liable for any lost revenue or profits or
  17.  * other special, indirect and consequential damages.
  18.  *
  19.  * Comments and additions should be sent to the author:
  20.  *
  21.  *                     Patrick J. Naughton
  22.  *                     Sun Microsystems
  23.  *                     2550 Garcia Ave, MS 10-20
  24.  *                     Mountain View, CA 94043
  25.  *                     (415) 336-1080
  26.  *
  27.  */
  28.  
  29. #include <sys/time.h>
  30. #include "grasp.h"
  31.  
  32. #define FADE_SNAP    0
  33. #define FADE_WIPELR    1
  34. #define FADE_WIPERL    2
  35. #define FADE_WIPESC    3
  36. #define FADE_WIPECS    4
  37. #define FADE_ILACESIM    5
  38. #define FADE_ILACE    6
  39. #define FADE_WIPETLRBRL    7
  40. #define FADE_WIPELLRRLR    8
  41. #define FADE_WIPETB    9
  42. #define FADE_WIPEBT    10
  43. #define FADE_WIPETCBC    11
  44. #define FADE_WIPECTB    12
  45. #define FADE_ILACETBBT    13
  46. #define FADE_WIPETTBBTB    14
  47. #define FADE_WIPELTBRBT    15
  48. #define FADE_QUARTERS    16
  49. #define FADE_COLUMNS    17
  50. #define FADE_DOUBLEINT    18
  51. #define FADE_POUR    19
  52. #define FADE_SPARKLE    20
  53. #define FADE_DIAGONAL    21
  54. #define FADE_OPEN_AP    22
  55. #define FADE_CLOSE_AP    23
  56. #define FADE_CLOCK    24
  57. #define FADE_DOUBLEARC    25
  58.  
  59. #define ILACEW 16
  60. #define WIPEW 4
  61.  
  62. extern ImageStruct *picreg[16];
  63.  
  64. void
  65. imagefade(fadestyle, im, xo, yo, speed, clip)
  66.     int         fadestyle;
  67.     ImageStruct *im;
  68.     int         speed;
  69.     int         xo;
  70.     int         yo;
  71.     int         clip;
  72. {
  73.     int         i;
  74.     int         j;
  75.     int         k;
  76.     int         w = im->w;
  77.     int         h = im->h;
  78.     int         halfh = (h + 1) / 2;
  79.     int         halfw = (w + 1) / 2;
  80.     int         hpar = h & 1;
  81.     int         wpar = w & 1;
  82.  
  83.     if (videomode < '4') {
  84.     int         lastattr = -1;
  85.     XImage     *xim = XGetImage(dsp, im->pix, 0, 0, w, h, 0xff, ZPixmap);
  86.     for (j = 0; j < h; j++) {
  87.         char       *row = &xim->data[j * w];
  88.         for (i = 0; i < w / 2;) {
  89.         char        s[81];
  90.         char        attr = 0;
  91.  
  92.         k = i;
  93.         do {
  94.             char        attr1 = row[2 * k + 1];
  95.             char        ch = row[2 * k];
  96.  
  97.             if (ch == 0)
  98.             s[k - i] = 32;
  99.             else {
  100.             s[k - i] = ch;
  101.             if (attr == 0) {
  102.                 if (attr1 != 0)
  103.                 attr = attr1;
  104.             } else if (attr != attr1)
  105.                 break;
  106.             }
  107.             k++;
  108.         } while (k < w / 2);
  109.         s[k - i] = 0;
  110.         if (attr != lastattr) {
  111.             XSetForeground(dsp, gc, attr & 0x0f);
  112.             XSetBackground(dsp, gc, (attr >> 4) & 0x0f);
  113.             lastattr = attr;
  114.         }
  115.         XDrawImageString(dsp, win, gc, i * 8, (j + 1) * 13 - 1, s, k - i);
  116.         i = k;
  117.         }
  118.     }
  119.     free(xim->data);
  120.     free(xim);
  121.     return;
  122.     }
  123.  
  124.     if (clip)
  125.         XSetClipRectangles(dsp, gc, 0, 0, &window, 1, 0);
  126.  
  127.     switch (fadestyle) {
  128.  
  129.     default:
  130.  
  131.     case FADE_SNAP:    /* 0 */
  132.     XCopyArea(dsp, im->pix, win, gc,
  133.           0, 0, w, h, xo, yo);
  134.     break;
  135.  
  136.     case FADE_WIPELR:    /* 1 */
  137.     for (i = 0; i < w; i += WIPEW)
  138.         XCopyArea(dsp, im->pix, win, gc,
  139.               i, 0, WIPEW, h, xo + i, yo);
  140.     break;
  141.  
  142.     case FADE_WIPERL:    /* 2 */
  143.     for (i = w - WIPEW; i > -WIPEW; i -= WIPEW)
  144.         XCopyArea(dsp, im->pix, win, gc,
  145.               i, 0, WIPEW, h, xo + i, yo);
  146.     break;
  147.  
  148.     case FADE_WIPESC:    /* 3 */
  149.     for (i = 0; i <= halfw; i += WIPEW) {
  150.         XCopyArea(dsp, im->pix, win, gc,
  151.               i, 0, WIPEW, h, xo + i, yo + 0);
  152.         XCopyArea(dsp, im->pix, win, gc,
  153.               w - WIPEW - i, 0, WIPEW, h, xo + w - WIPEW - i, yo);
  154.     }
  155.     break;
  156.  
  157.     case FADE_WIPECS:    /* 4 */
  158.     for (i = halfw; i >= -WIPEW; i -= WIPEW) {
  159.         XCopyArea(dsp, im->pix, win, gc,
  160.               i, 0, WIPEW, h, xo + i, yo);
  161.         XCopyArea(dsp, im->pix, win, gc,
  162.               w - WIPEW - i, 0, WIPEW, h, xo + w - WIPEW - i, yo);
  163.     }
  164.     break;
  165.  
  166.     case FADE_ILACESIM:    /* 5 */
  167.     for (i = 0; i <= w - ILACEW; i += ILACEW)
  168.         for (j = 0; j < h; j += 2) {
  169.         XCopyArea(dsp, im->pix, win, gc,
  170.               i, j, ILACEW, 1, xo + i, yo + j);
  171.         XCopyArea(dsp, im->pix, win, gc,
  172.               w - ILACEW - i, j + 1, ILACEW, 1,
  173.               xo + w - ILACEW - i, yo + j + 1);
  174.         }
  175.     break;
  176.  
  177.     case FADE_ILACE:    /* 6 */
  178.     for (i = 0; i <= w - ILACEW; i += ILACEW)
  179.         for (j = 0; j < h; j += 2)
  180.         XCopyArea(dsp, im->pix, win, gc,
  181.               i, j, ILACEW, 1, xo + i, yo + j);
  182.     for (i = 0; i <= w - ILACEW; i += ILACEW)
  183.         for (j = 0; j < h; j += 2)
  184.         XCopyArea(dsp, im->pix, win, gc,
  185.               w - ILACEW - i, j + 1, ILACEW, 1,
  186.               xo + w - ILACEW - i, yo + j + 1);
  187.     break;
  188.  
  189.     case FADE_WIPETLRBRL:    /* 7 */
  190.     for (i = 0; i <= w - WIPEW; i += WIPEW)
  191.         XCopyArea(dsp, im->pix, win, gc,
  192.               i, halfh, WIPEW, h - halfh, xo + i, yo + halfh);
  193.     for (i = w - WIPEW; i > -WIPEW; i -= WIPEW)
  194.         XCopyArea(dsp, im->pix, win, gc,
  195.               i, 0, WIPEW, halfh, xo + i, yo);
  196.     break;
  197.  
  198.     case FADE_WIPELLRRLR:    /* 8 */
  199.     for (i = 0; i < halfw; i += WIPEW) {
  200.         XCopyArea(dsp, im->pix, win, gc,
  201.               i, 0, WIPEW, h, xo + i, yo);
  202.         XCopyArea(dsp, im->pix, win, gc,
  203.               halfw + i, 0, WIPEW, h, xo + halfw + i, yo);
  204.     }
  205.     break;
  206.  
  207.     case FADE_WIPETB:    /* 9 */
  208.     for (j = 0; j < h; j++)
  209.         XCopyArea(dsp, im->pix, win, gc,
  210.               0, j, w, 1, xo, yo + j);
  211.     break;
  212.  
  213.     case FADE_WIPEBT:    /* 10 */
  214.     for (j = h; j >= 0; j--)
  215.         XCopyArea(dsp, im->pix, win, gc,
  216.               0, j, w, 1, xo, yo + j);
  217.     break;
  218.  
  219.     case FADE_WIPETCBC:    /* 11 */
  220.     for (j = 0; j < halfh + hpar; j++) {
  221.         XCopyArea(dsp, im->pix, win, gc,
  222.               0, j, w, 1, xo, yo + j);
  223.         XCopyArea(dsp, im->pix, win, gc,
  224.               0, h - j - 1, w, 1, xo, yo + h - j - 1);
  225.     }
  226.     break;
  227.  
  228.     case FADE_WIPECTB:    /* 12 */
  229.     for (j = halfh + hpar - 1; j >= 0; j--) {
  230.         XCopyArea(dsp, im->pix, win, gc,
  231.               0, j, w, 1, xo, yo + j);
  232.         XCopyArea(dsp, im->pix, win, gc,
  233.               0, h - j - 1, w, 1, xo, yo + h - j - 1);
  234.     }
  235.     break;
  236.  
  237.     case FADE_ILACETBBT:    /* 13 */
  238.     for (j = 0; j < h; j += 2) {
  239.         XCopyArea(dsp, im->pix, win, gc,
  240.               0, j, w, 1, xo, yo + j);
  241.         XSync(dsp, False);
  242.     }
  243.     for (j = h - 1 - hpar; j > 0; j -= 2) {
  244.         XCopyArea(dsp, im->pix, win, gc,
  245.               0, j, w, 1, xo, yo + j);
  246.         XSync(dsp, False);
  247.     }
  248.     break;
  249.  
  250.     case FADE_WIPETTBBTB:    /* 14 */
  251.     for (j = 0; j < halfh + hpar; j++) {
  252.         XCopyArea(dsp, im->pix, win, gc,
  253.               0, j, w, 1, xo, yo + j);
  254.         XCopyArea(dsp, im->pix, win, gc,
  255.               0, halfh + j, w, 1, xo, yo + halfh + j);
  256.         XSync(dsp, False);
  257.     }
  258.     break;
  259.  
  260.     case FADE_WIPELTBRBT:    /* 15 */
  261.     for (j = 0; j < h; j++) {
  262.         XCopyArea(dsp, im->pix, win, gc,
  263.               0, j, halfw, 1, xo, yo + j);
  264.         XCopyArea(dsp, im->pix, win, gc,
  265.               halfw, h - j, halfw, 1, xo + halfw, yo + h - j);
  266.         XSync(dsp, False);
  267.     }
  268.     break;
  269.  
  270.     case FADE_QUARTERS:    /* 16 */
  271.  
  272.     /* top left, top to bottom */
  273.     for (j = 0; j <= halfh + hpar; j++) {
  274.         XCopyArea(dsp, im->pix, win, gc,
  275.               0, j, halfw + wpar, 1, xo, yo + j);
  276.         XSync(dsp, False);
  277.     }
  278.  
  279.     /* bottom right, top to bottom */
  280.     for (j = halfh + hpar; j < h; j++) {
  281.         XCopyArea(dsp, im->pix, win, gc,
  282.               halfw + wpar, j, halfw, 1, xo + halfw + wpar, yo + j);
  283.         XSync(dsp, False);
  284.     }
  285.  
  286.     /* bottom left, bottom to top */
  287.     for (j = h; j >= halfh; j--) {
  288.         XCopyArea(dsp, im->pix, win, gc,
  289.               0, j, halfw + wpar, 1, xo, yo + j);
  290.         XSync(dsp, False);
  291.     }
  292.  
  293.     /* top right, bottom to top */
  294.     for (j = halfh; j >= 0; j--) {
  295.         XCopyArea(dsp, im->pix, win, gc,
  296.               halfw + wpar, j, halfw, 1, xo + halfw + wpar, yo + j);
  297.         XSync(dsp, False);
  298.     }
  299.     break;
  300.  
  301.     case FADE_COLUMNS:    /* 17 */
  302.     for (j = 0; j < h; j += 2)
  303.         for (i = 0; i < w; i += 16)
  304.         XCopyArea(dsp, im->pix, win, gc,
  305.               i, j, 8, 2, xo + i, yo + j);
  306.  
  307.     for (j = h - 1; j >= -1; j -= 2)
  308.         for (i = 8; i < w; i += 16)
  309.         XCopyArea(dsp, im->pix, win, gc,
  310.               i, j, 8, 2, xo + i, yo + j);
  311.  
  312.     break;
  313.  
  314.     case FADE_DOUBLEINT:    /* 18 */
  315.     for (j = 0; j < h; j += 2)
  316.         for (i = 0; i < w; i += 16)
  317.         XCopyArea(dsp, im->pix, win, gc,
  318.               i, j, 8, 1, xo + i, yo + j);
  319.     for (j = h - 1; j >= 0; j -= 2)
  320.         for (i = 8; i < w; i += 16)
  321.         XCopyArea(dsp, im->pix, win, gc,
  322.               i, j, 8, 1, xo + i, yo + j);
  323.     for (j = 1; j < h; j += 2)
  324.         for (i = 0; i < w; i += 16)
  325.         XCopyArea(dsp, im->pix, win, gc,
  326.               i, j, 8, 1, xo + i, yo + j);
  327.     for (j = h - 2; j >= 0; j -= 2)
  328.         for (i = 8; i < w; i += 16)
  329.         XCopyArea(dsp, im->pix, win, gc,
  330.               i, j, 8, 1, xo + i, yo + j);
  331.     break;
  332.  
  333.     case FADE_POUR:    /* 19 */
  334.     for (j = h - 1; j >= 0; j -= WIPEW)
  335.         for (i = 0; i < j; i++)
  336.         XCopyArea(dsp, im->pix, win, gc,
  337.               0, j, w, WIPEW, xo + 0, yo + i);
  338.     break;
  339.  
  340.     case FADE_SPARKLE:    /* 20 */
  341.     {
  342.         int         boxsize = (w + 39) / 40;
  343.         int         cols = (w + (boxsize - 1)) / boxsize;
  344.         int         boxcount = (h + (boxsize - 1)) / boxsize * cols;
  345.         int        *order = (int *) malloc(boxcount * sizeof(int));
  346.  
  347.         (void) srandom(getpid());
  348.         for (i = 0; i < boxcount; i++)
  349.         order[i] = i;
  350.         for (i = 0; i < boxcount * boxsize; i++) {
  351.         int         i1 = random() % boxcount;
  352.         int         i2 = random() % boxcount;
  353.         j = order[i1];
  354.         order[i1] = order[i2];
  355.         order[i2] = j;
  356.         }
  357.         for (i = 0; i < boxcount; i++) {
  358.         int         x = (order[i] % cols) * boxsize;
  359.         int         y = (order[i] / cols) * boxsize;
  360.         XCopyArea(dsp, im->pix, win, gc,
  361.               x, y, boxsize, boxsize, xo + x, yo + y);
  362.         }
  363.         free(order);
  364.     }
  365.     break;
  366.  
  367.     case FADE_DIAGONAL:    /* 21 *//* not implemented */
  368.     XCopyArea(dsp, im->pix, win, gc,
  369.           0, 0, w, h, xo, yo);
  370.     break;
  371.     case FADE_OPEN_AP:    /* 22 */
  372.     for (i = 0; i <= MAX(w, h) / 2; i += WIPEW) {
  373.         /* left wedge */
  374.         XCopyArea(dsp, im->pix, win, gc,
  375.               halfw - i, halfh - i, WIPEW, 2 * i,
  376.               xo + halfw - i, yo + halfh - i);
  377.         /* top wedge */
  378.         XCopyArea(dsp, im->pix, win, gc,
  379.               halfw - i, halfh - i, 2 * i, WIPEW,
  380.               xo + halfw - i, yo + halfh - i);
  381.         /* right wedge */
  382.         XCopyArea(dsp, im->pix, win, gc,
  383.               halfw + i, halfh - i, WIPEW, 2 * i + WIPEW,
  384.               xo + halfw + i, yo + halfh - i);
  385.         /* bottom wedge */
  386.         XCopyArea(dsp, im->pix, win, gc,
  387.               halfw - i, halfh + i, 2 * i + WIPEW, WIPEW,
  388.               xo + halfw - i, yo + halfh + i);
  389.         XSync(dsp, False);
  390.     }
  391.     break;
  392.     case FADE_CLOSE_AP:    /* 23 */
  393.     for (i = MAX(w, h) / 2; i >= 0; i -= WIPEW) {
  394.         /* left wedge */
  395.         XCopyArea(dsp, im->pix, win, gc,
  396.               halfw - i, halfh - i, WIPEW, 2 * i,
  397.               xo + halfw - i, yo + halfh - i);
  398.         /* top wedge */
  399.         XCopyArea(dsp, im->pix, win, gc,
  400.               halfw - i, halfh - i, 2 * i, WIPEW,
  401.               xo + halfw - i, yo + halfh - i);
  402.         /* right wedge */
  403.         XCopyArea(dsp, im->pix, win, gc,
  404.               halfw + i, halfh - i, WIPEW, 2 * i + WIPEW,
  405.               xo + halfw + i, yo + halfh - i);
  406.         /* bottom wedge */
  407.         XCopyArea(dsp, im->pix, win, gc,
  408.               halfw - i, halfh + i, 2 * i + WIPEW, WIPEW,
  409.               xo + halfw - i, yo + halfh + i);
  410.         XSync(dsp, False);
  411.     }
  412.     break;
  413.     case FADE_CLOCK:    /* 24 *//* not implemented */
  414.     XCopyArea(dsp, im->pix, win, gc,
  415.           0, 0, w, h, xo, yo);
  416.     break;
  417.     case FADE_DOUBLEARC:    /* 25 *//* not implemented */
  418.     XCopyArea(dsp, im->pix, win, gc,
  419.           0, 0, w, h, xo, yo);
  420.     break;
  421.     }
  422.     XSetClipMask(dsp, gc, None);
  423.     XSync(dsp, False);
  424. }
  425.